const express = require('express');
const { authenticateToken, requirePermissions } = require('../middleware/auth');
const { upload, getFileUrl } = require('../middleware/upload');
const MiniappImage = require('../models/MiniappImage');

const router = express.Router();

/**
 * 获取小程序图片配置列表（管理员）
 * GET /api/miniapp-images
 */
router.get('/', authenticateToken, requirePermissions(['system:config']), async (req, res) => {
  try {
    const { page_name, image_type, is_active } = req.query;

    const options = {};
    if (page_name) options.page_name = page_name;
    if (image_type) options.image_type = image_type;

    // 修复布尔值处理逻辑
    if (is_active !== undefined && is_active !== '') {
      // 处理多种可能的布尔值表示
      if (typeof is_active === 'boolean') {
        options.is_active = is_active;
      } else if (typeof is_active === 'string') {
        options.is_active = is_active === 'true' || is_active === '1';
      } else {
        options.is_active = Boolean(is_active);
      }
    }

    const images = await MiniappImage.findAll(options);

    res.success(images, '获取图片配置列表成功');
  } catch (error) {
    console.error('获取图片配置列表失败:', error);
    res.error('获取图片配置列表失败', 500, error.message);
  }
});

/**
 * 获取单个图片配置（管理员）
 * GET /api/miniapp-images/:id
 */
router.get('/:id', authenticateToken, requirePermissions(['system:config']), async (req, res) => {
  try {
    const { id } = req.params;
    const image = await MiniappImage.findById(parseInt(id));
    
    if (!image) {
      return res.error('图片配置不存在', 404);
    }
    
    res.success(image, '获取图片配置成功');
  } catch (error) {
    console.error('获取图片配置失败:', error);
    res.error('获取图片配置失败', 500, error.message);
  }
});

/**
 * 创建图片配置（管理员）
 * POST /api/miniapp-images
 */
router.post('/', authenticateToken, requirePermissions(['system:config']), async (req, res) => {
  try {
    const {
      image_key,
      image_name,
      image_url,
      image_type,
      page_name,
      sort_order,
      is_active,
      description
    } = req.body;

    // 验证必填字段
    if (!image_key || !image_name || !image_url || !page_name) {
      return res.error('图片键、图片名称、图片URL和页面名称不能为空', 400);
    }

    // 检查图片键是否已存在
    const keyExists = await MiniappImage.keyExists(image_key);
    if (keyExists) {
      return res.error('图片键已存在', 400);
    }

    // 确保布尔值正确处理
    let activeStatus = true;
    if (is_active !== undefined) {
      if (typeof is_active === 'boolean') {
        activeStatus = is_active;
      } else if (typeof is_active === 'string') {
        activeStatus = is_active === 'true' || is_active === '1';
      } else {
        activeStatus = Boolean(is_active);
      }
    }

    const imageData = {
      image_key: image_key.trim(),
      image_name: image_name.trim(),
      image_url: image_url.trim(),
      image_type: image_type || 'icon',
      page_name: page_name.trim(),
      sort_order: sort_order || 99,
      is_active: activeStatus,
      description: description || ''
    };

    const newImage = await MiniappImage.create(imageData);
    
    res.success(newImage, '创建图片配置成功');
  } catch (error) {
    console.error('创建图片配置失败:', error);
    res.error('创建图片配置失败', 500, error.message);
  }
});

/**
 * 更新图片配置（管理员）
 * PUT /api/miniapp-images/:id
 */
router.put('/:id', authenticateToken, requirePermissions(['system:config']), async (req, res) => {
  try {
    const { id } = req.params;
    const updateData = { ...req.body };

    // 检查图片配置是否存在
    const existingImage = await MiniappImage.findById(parseInt(id));
    if (!existingImage) {
      return res.error('图片配置不存在', 404);
    }

    // 如果更新了图片键，检查是否重复
    if (updateData.image_key && updateData.image_key !== existingImage.image_key) {
      const keyExists = await MiniappImage.keyExists(updateData.image_key, parseInt(id));
      if (keyExists) {
        return res.error('图片键已存在', 400);
      }
    }

    // 确保 is_active 字段的布尔值正确处理
    if (updateData.hasOwnProperty('is_active')) {
      const { is_active } = updateData;
      if (typeof is_active === 'boolean') {
        updateData.is_active = is_active;
      } else if (typeof is_active === 'string') {
        updateData.is_active = is_active === 'true' || is_active === '1';
      } else {
        updateData.is_active = Boolean(is_active);
      }
    }

    const updatedImage = await MiniappImage.update(parseInt(id), updateData);

    res.success(updatedImage, '更新图片配置成功');
  } catch (error) {
    console.error('更新图片配置失败:', error);
    res.error('更新图片配置失败', 500, error.message);
  }
});

/**
 * 删除图片配置（管理员）
 * DELETE /api/miniapp-images/:id
 */
router.delete('/:id', authenticateToken, requirePermissions(['system:config']), async (req, res) => {
  try {
    const { id } = req.params;

    // 检查图片配置是否存在
    const existingImage = await MiniappImage.findById(parseInt(id));
    if (!existingImage) {
      return res.error('图片配置不存在', 404);
    }

    const success = await MiniappImage.delete(parseInt(id));
    
    if (success) {
      res.success(null, '删除图片配置成功');
    } else {
      res.error('删除图片配置失败', 500);
    }
  } catch (error) {
    console.error('删除图片配置失败:', error);
    res.error('删除图片配置失败', 500, error.message);
  }
});

/**
 * 批量更新排序（管理员）
 * PUT /api/miniapp-images/sort
 */
router.put('/sort', authenticateToken, requirePermissions(['system:config']), async (req, res) => {
  try {
    const { sortData } = req.body;

    if (!Array.isArray(sortData) || sortData.length === 0) {
      return res.error('排序数据格式错误', 400);
    }

    // 验证排序数据格式
    for (const item of sortData) {
      if (!item.id || typeof item.sort_order !== 'number') {
        return res.error('排序数据格式错误', 400);
      }
    }

    await MiniappImage.updateSort(sortData);
    
    res.success(null, '更新排序成功');
  } catch (error) {
    console.error('更新排序失败:', error);
    res.error('更新排序失败', 500, error.message);
  }
});

/**
 * 获取图片配置统计信息（管理员）
 * GET /api/miniapp-images/stats
 */
router.get('/stats', authenticateToken, requirePermissions(['system:config']), async (req, res) => {
  try {
    const stats = await MiniappImage.getStats();
    
    res.success(stats, '获取统计信息成功');
  } catch (error) {
    console.error('获取统计信息失败:', error);
    res.error('获取统计信息失败', 500, error.message);
  }
});

/**
 * 上传小程序图片（管理员）
 * POST /api/miniapp-images/upload
 */
router.post('/upload', authenticateToken, requirePermissions(['system:config']), upload.single('image'), async (req, res) => {
  try {
    if (!req.file) {
      return res.error('请选择要上传的图片文件', 400);
    }

    // 根据文件存储路径确定子目录
    const pathParts = req.file.path.split('/');
    const subDir = pathParts[pathParts.length - 2];
    
    const fileUrl = getFileUrl(req, req.file.filename, subDir);

    res.success({
      url: fileUrl,
      filename: req.file.filename,
      originalName: req.file.originalname,
      size: req.file.size,
      mimetype: req.file.mimetype
    }, '图片上传成功');

  } catch (error) {
    console.error('上传图片失败:', error);
    res.error('上传图片失败', 500, error.message);
  }
});

module.exports = router;
